package com.ruoyi.common.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;
import java.util.concurrent.CompletableFuture;

@Service
public class FileAsyncService {

    private static final Logger log = LoggerFactory.getLogger(FileAsyncService.class);

    /**
     * 异步读取小文件（一次性加载到内存，适合文件大小 < 100MB）
     * @param filePath 本地文件路径（如 D:/data/test.txt）
     * @return CompletableFuture<List<String>>：异步结果（文件内容按行存储）
     */
    @Async("fileAsyncExecutor") // 指定使用自定义线程池
    public CompletableFuture<List<String>> readSmallFileAsync(String filePath) throws IOException {
        log.info("异步读取小文件：{}，线程名：{}", filePath, Thread.currentThread().getName());

        // 验证文件存在
        File file = new File(filePath);
        if (!file.exists()) {
            throw new IOException("文件不存在：" + filePath);
        }
        if (!file.isFile()) {
            throw new IOException("不是文件：" + filePath);
        }

        // 读取文件内容（按行存储）
        List<String> fileContent = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);

        log.info("小文件读取完成：{}，共 {} 行", filePath, fileContent.size());
        return CompletableFuture.completedFuture(fileContent);
    }

    /**
     * 异步读取大文件（分块流式读取，避免内存溢出，适合文件大小 > 100MB）
     * @param filePath 本地文件路径
     * @param callback 每行数据的回调处理（如解析、存储）
     * @return CompletableFuture<Long>：异步结果（读取的总行数）
     */
    @Async("fileAsyncExecutor")
    public CompletableFuture<Long> readLargeFileAsync(String filePath, LineCallback callback) throws IOException {
        log.info("异步读取大文件：{}，线程名：{}", filePath, Thread.currentThread().getName());

        File file = new File(filePath);
        if (!file.exists() || !file.isFile()) {
            throw new IOException("文件不存在或不是文件：" + filePath);
        }

        long lineCount = 0;
        // 流式读取，逐行处理
        try (BufferedReader reader = new BufferedReader(new FileReader(file, StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lineCount++;
                // 回调处理每行数据（如写入数据库、解析内容）
                callback.process(line, lineCount);
            }
        }

        log.info("大文件读取完成：{}，共 {} 行", filePath, lineCount);
        return CompletableFuture.completedFuture(lineCount);
    }

    /**
     * 函数式接口：大文件每行数据的回调处理
     */
    @FunctionalInterface
    public interface LineCallback {
        /**
         * 处理每行数据
         * @param line 行内容
         * @param lineNum 行号（从 1 开始）
         */
        void process(String line, long lineNum);
    }
}
